ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನ: ಸುಧಾರಿತ ಮಾಡ್ಯೂಲ್ ಡಿಕ್ಲರೇಶನ್ ಮಾದರಿಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿಮ್ಮ ಕೋಡನ್ನು ರಚಿಸಲು ಮತ್ತು ಸಂಘಟಿಸಲು ಪ್ರಬಲ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ. ಅಂತಹ ಒಂದು ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನ, ಇದು ನಿಮಗೆ ಒಂದೇ ಹೆಸರಿನೊಂದಿಗೆ ಬಹು ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅವುಗಳ ಘೋಷಣೆಗಳನ್ನು ಒಂದೇ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ. ಈ ಸಾಮರ್ಥ್ಯವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ವಿಸ್ತರಿಸಲು, ಮಾಡ್ಯುಲರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು, ಮತ್ತು ಸಂಕೀರ್ಣ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯು ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸುವ ಸುಧಾರಿತ ಮಾದರಿಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಇದು ನಿಮಗೆ ಸ್ವಚ್ಛವಾದ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಬರೆಯಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ.

ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳು ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನದ ಬಗ್ಗೆ ತಿಳಿಯುವ ಮೊದಲು, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳು ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ಗಳ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಎರಡೂ ಕೋಡ್ ಸಂಘಟನೆಗಾಗಿ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸಿದರೂ, ಅವು ತಮ್ಮ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಬಳಕೆಯಲ್ಲಿ ಗಮನಾರ್ಹವಾಗಿ ಭಿನ್ನವಾಗಿವೆ.

ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳು (ಆಂತರಿಕ ಮಾಡ್ಯೂಲ್‌ಗಳು)

ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳು ಸಂಬಂಧಿತ ಕೋಡ್ ಅನ್ನು ಒಟ್ಟಿಗೆ ಗುಂಪು ಮಾಡಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌-ನಿರ್ದಿಷ್ಟ ರಚನೆಯಾಗಿದೆ. ಅವು ಮೂಲಭೂತವಾಗಿ ನಿಮ್ಮ ಫಂಕ್ಷನ್‌ಗಳು, ಕ್ಲಾಸ್‌ಗಳು, ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ವೇರಿಯಬಲ್‌ಗಳಿಗಾಗಿ ಹೆಸರಿಸಲಾದ ಕಂಟೇನರ್‌ಗಳನ್ನು ರಚಿಸುತ್ತವೆ. ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ಮುಖ್ಯವಾಗಿ ಒಂದೇ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಆಂತರಿಕ ಕೋಡ್ ಸಂಘಟನೆಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ES ಮಾಡ್ಯೂಲ್‌ಗಳ ಏರಿಕೆಯೊಂದಿಗೆ, ಹಳೆಯ ಕೋಡ್‌ಬೇಸ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಜಾಗತಿಕ ವರ್ಧನೆ ಸನ್ನಿವೇಶಗಳು ನಿಮಗೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕಡಿಮೆ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ:

namespace Geometry {
  export interface Shape {
    getArea(): number;
  }

  export class Circle implements Shape {
    constructor(public radius: number) {}

    getArea(): number {
      return Math.PI * this.radius * this.radius;
    }
  }
}

const myCircle = new Geometry.Circle(5);
console.log(myCircle.getArea()); // Output: 78.53981633974483

ಮಾಡ್ಯೂಲ್‌ಗಳು (ಬಾಹ್ಯ ಮಾಡ್ಯೂಲ್‌ಗಳು)

ಮತ್ತೊಂದೆಡೆ, ಮಾಡ್ಯೂಲ್‌ಗಳು ಕೋಡ್ ಅನ್ನು ಸಂಘಟಿಸಲು ಒಂದು ಪ್ರಮಾಣಿತ ಮಾರ್ಗವಾಗಿದ್ದು, ES ಮಾಡ್ಯೂಲ್‌ಗಳು (ECMAScript ಮಾಡ್ಯೂಲ್‌ಗಳು) ಮತ್ತು CommonJS ನಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಮಾಡ್ಯೂಲ್‌ಗಳು ತಮ್ಮದೇ ಆದ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿರುತ್ತವೆ ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಇಂಪೋರ್ಟ್ ಮತ್ತು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡುತ್ತವೆ, ಇದರಿಂದಾಗಿ ಅವು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕಾಂಪೊನೆಂಟ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳನ್ನು ರಚಿಸಲು ಸೂಕ್ತವಾಗಿವೆ. ES ಮಾಡ್ಯೂಲ್‌ಗಳು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಪ್ರಮಾಣಿತವಾಗಿವೆ.

ಉದಾಹರಣೆ:

// circle.ts
export interface Shape {
  getArea(): number;
}

export class Circle implements Shape {
  constructor(public radius: number) {}

  getArea(): number {
    return Math.PI * this.radius * this.radius;
  }
}

// app.ts
import { Circle } from './circle';

const myCircle = new Circle(5);
console.log(myCircle.getArea());

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನದ ಶಕ್ತಿ

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವು ಒಂದೇ ನೇಮ್‌ಸ್ಪೇಸ್ ಹೆಸರಿನೊಂದಿಗೆ ಕೋಡ್‌ನ ಬಹು ಬ್ಲಾಕ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಘೋಷಣೆಗಳನ್ನು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಒಂದೇ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ಬುದ್ಧಿವಂತಿಕೆಯಿಂದ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ. ಈ ಸಾಮರ್ಥ್ಯವು ಇದಕ್ಕಾಗಿ ಅಮೂಲ್ಯವಾಗಿದೆ:

• ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಲೈಬ್ರರಿಗಳಿಗೆ ಅವುಗಳ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಮಾರ್ಪಡಿಸದೆ ಹೊಸ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಿ.
• ಕೋಡ್ ಅನ್ನು ಮಾಡ್ಯುಲೈಸ್ ಮಾಡುವುದು: ದೊಡ್ಡ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ಚಿಕ್ಕದಾದ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಫೈಲ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿ.
• ಆಂಬಿಯೆಂಟ್ ಡಿಕ್ಲರೇಶನ್‌ಗಳು: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್‌ಗಳಿಲ್ಲದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ.

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನದೊಂದಿಗೆ ಸುಧಾರಿತ ಮಾಡ್ಯೂಲ್ ಡಿಕ್ಲರೇಶನ್ ಮಾದರಿಗಳು

ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸುವ ಕೆಲವು ಸುಧಾರಿತ ಮಾದರಿಗಳನ್ನು ಪರಿಶೋಧಿಸೋಣ.

1. ಆಂಬಿಯೆಂಟ್ ಡಿಕ್ಲರೇಶನ್‌ಗಳೊಂದಿಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನದ ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳಲ್ಲಿ ಒಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳನ್ನು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳೊಂದಿಗೆ ವಿಸ್ತರಿಸುವುದು. ನೀವು `my-library` ಎಂಬ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, ಅದಕ್ಕೆ ಅಧಿಕೃತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬೆಂಬಲವಿಲ್ಲ. ಈ ಲೈಬ್ರರಿಗಾಗಿ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀವು ಆಂಬಿಯೆಂಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ (ಉದಾ., `my-library.d.ts`) ಅನ್ನು ರಚಿಸಬಹುದು.

ಉದಾಹರಣೆ:

// my-library.d.ts
declare namespace MyLibrary {
  interface Options {
    apiKey: string;
    timeout?: number;
  }

  function initialize(options: Options): void;
  function fetchData(endpoint: string): Promise;
}

ಈಗ, ನೀವು ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನಲ್ಲಿ `MyLibrary` ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ಟೈಪ್ ಸುರಕ್ಷತೆಯೊಂದಿಗೆ ಬಳಸಬಹುದು:

// app.ts
MyLibrary.initialize({
  apiKey: 'YOUR_API_KEY',
  timeout: 5000,
});

MyLibrary.fetchData('/api/data')
  .then(data => {
    console.log(data);
  });

ನೀವು ನಂತರ `MyLibrary` ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳಿಗೆ ಹೆಚ್ಚಿನ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಬೇಕಾದರೆ, ನೀವು ಮತ್ತೊಂದು `my-library.d.ts` ಫೈಲ್ ಅನ್ನು ರಚಿಸಬಹುದು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಒಂದಕ್ಕೆ ಸೇರಿಸಬಹುದು:

// my-library.d.ts

declare namespace MyLibrary {
  interface Options {
    apiKey: string;
    timeout?: number;
  }

  function initialize(options: Options): void;
  function fetchData(endpoint: string): Promise;

  // Add a new function to the MyLibrary namespace
  function processData(data: any): any;
}

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಘೋಷಣೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ, ಇದರಿಂದ ನೀವು ಹೊಸ `processData` ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು.

2. ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವರ್ಧಿಸುವುದು

ಕೆಲವೊಮ್ಮೆ, ನೀವು `String`, `Number`, ಅಥವಾ `Array` ನಂತಹ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪ್ರಾಪರ್ಟೀಸ್ ಅಥವಾ ಮೆಥಡ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಬಯಸಬಹುದು. ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವು ಇದನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಮತ್ತು ಟೈಪ್ ಪರಿಶೀಲನೆಯೊಂದಿಗೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

// string.extensions.d.ts
declare global {
  interface String {
    reverse(): string;
  }
}

String.prototype.reverse = function() {
  return this.split('').reverse().join('');
};

console.log('hello'.reverse()); // Output: olleh

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು `String` ಪ್ರೊಟೊಟೈಪ್‌ಗೆ `reverse` ಮೆಥಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತಿದ್ದೇವೆ. `declare global` ಸಿಂಟ್ಯಾಕ್ಸ್ ನಾವು ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳುತ್ತದೆ. ಇದು ಸಾಧ್ಯವಾದರೂ, ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವರ್ಧಿಸುವುದು ಕೆಲವೊಮ್ಮೆ ಇತರ ಲೈಬ್ರರಿಗಳು ಅಥವಾ ಭವಿಷ್ಯದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾನದಂಡಗಳೊಂದಿಗೆ ಸಂಘರ್ಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ. ಈ ತಂತ್ರವನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸಿ.

ಅಂತಾರಾಷ್ಟ್ರೀಕರಣದ ಪರಿಗಣನೆಗಳು: ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು, ವಿಶೇಷವಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಥವಾ ಸಂಖ್ಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೆಥಡ್‌ಗಳೊಂದಿಗೆ ವರ್ಧಿಸುವಾಗ, ಅಂತಾರಾಷ್ಟ್ರೀಕರಣದ ಬಗ್ಗೆ ಜಾಗೃತರಾಗಿರಿ. ಮೇಲಿನ `reverse` ಫಂಕ್ಷನ್ ಮೂಲಭೂತ ASCII ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಆದರೆ ಇದು ಸಂಕೀರ್ಣ ಅಕ್ಷರ ಸೆಟ್‌ಗಳು ಅಥವಾ ಬಲದಿಂದ ಎಡಕ್ಕೆ ಬರೆಯುವ ದಿಕ್ಕನ್ನು ಹೊಂದಿರುವ ಭಾಷೆಗಳಿಗೆ ಸೂಕ್ತವಾಗಿರುವುದಿಲ್ಲ. ಲೊಕೇಲ್-ಅವೇರ್ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ಗಾಗಿ `Intl` ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

3. ದೊಡ್ಡ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ಮಾಡ್ಯುಲೈಸ್ ಮಾಡುವುದು

ದೊಡ್ಡ ಮತ್ತು ಸಂಕೀರ್ಣ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಅವುಗಳನ್ನು ಚಿಕ್ಕದಾದ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಫೈಲ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವುದು ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವು ಇದನ್ನು ಸುಲಭವಾಗಿ ಸಾಧಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

// geometry.ts
namespace Geometry {
  export interface Shape {
    getArea(): number;
  }
}

// circle.ts
namespace Geometry {
  export class Circle implements Shape {
    constructor(public radius: number) {}

    getArea(): number {
      return Math.PI * this.radius * this.radius;
    }
  }
}

// rectangle.ts
namespace Geometry {
  export class Rectangle implements Shape {
    constructor(public width: number, public height: number) {}

    getArea(): number {
      return this.width * this.height;
    }
  }
}

// app.ts
/// 
/// 
/// 

const myCircle = new Geometry.Circle(5);
const myRectangle = new Geometry.Rectangle(10, 5);

console.log(myCircle.getArea()); // Output: 78.53981633974483
console.log(myRectangle.getArea()); // Output: 50

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು `Geometry` ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ಮೂರು ಫೈಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಿದ್ದೇವೆ: `geometry.ts`, `circle.ts`, ಮತ್ತು `rectangle.ts`. ಪ್ರತಿಯೊಂದು ಫೈಲ್ `Geometry` ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತದೆ, ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ. `/// ` ಡೈರೆಕ್ಟಿವ್‌ಗಳ ಬಳಕೆಯನ್ನು ಗಮನಿಸಿ. ಇವುಗಳು ಕೆಲಸ ಮಾಡಿದರೂ, ಅವು ಹಳೆಯ ವಿಧಾನವಾಗಿದೆ, ಮತ್ತು ಆಧುನಿಕ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ಬಳಸುವಾಗಲೂ ES ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಯೋಗ್ಯವಾಗಿದೆ.

ಆಧುನಿಕ ಮಾಡ್ಯೂಲ್ ವಿಧಾನ (ಆದ್ಯತೆ):

// geometry.ts
export namespace Geometry {
  export interface Shape {
    getArea(): number;
  }
}

// circle.ts
import { Geometry } from './geometry';

export namespace Geometry {
  export class Circle implements Shape {
    constructor(public radius: number) {}

    getArea(): number {
      return Math.PI * this.radius * this.radius;
    }
  }
}

// rectangle.ts
import { Geometry } from './geometry';

export namespace Geometry {
  export class Rectangle implements Shape {
    constructor(public width: number, public height: number) {}

    getArea(): number {
      return this.width * this.height;
    }
  }
}

// app.ts
import { Geometry } from './geometry';
const myCircle = new Geometry.Circle(5);
const myRectangle = new Geometry.Rectangle(10, 5);

console.log(myCircle.getArea());
console.log(myRectangle.getArea());

ಈ ವಿಧಾನವು ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳೊಂದಿಗೆ ES ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೂಲಿಂಗ್‌ನೊಂದಿಗೆ ಉತ್ತಮ ಮಾಡ್ಯುಲಾರಿಟಿ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

4. ಇಂಟರ್ಫೇಸ್ ವರ್ಧನೆಯೊಂದಿಗೆ ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸುವುದು

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ಗಳ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವಿಸ್ತರಿಸಲು ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಇಂಟರ್ಫೇಸ್ ವರ್ಧನೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗುತ್ತದೆ. ಇದು ಇತರ ಲೈಬ್ರರಿಗಳು ಅಥವಾ ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಇಂಟರ್ಫೇಸ್‌ಗಳಿಗೆ ಹೊಸ ಪ್ರಾಪರ್ಟೀಸ್ ಅಥವಾ ಮೆಥಡ್‌ಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

// user.ts
interface User {
  id: number;
  name: string;
}

// user.extensions.ts
namespace User {
  export interface User {
    email: string;
  }
}

// app.ts
import { User } from './user'; // Assuming user.ts exports the User interface
import './user.extensions'; // Import for side-effect: augment the User interface

const myUser: User = {
  id: 123,
  name: 'John Doe',
  email: 'john.doe@example.com',
};

console.log(myUser.name);
console.log(myUser.email);

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನ ಮತ್ತು ಇಂಟರ್ಫೇಸ್ ವರ್ಧನೆಯನ್ನು ಬಳಸಿಕೊಂಡು `User` ಇಂಟರ್ಫೇಸ್‌ಗೆ `email` ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸುತ್ತಿದ್ದೇವೆ. `user.extensions.ts` ಫೈಲ್ `User` ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವರ್ಧಿಸುತ್ತದೆ. `app.ts` ನಲ್ಲಿ `./user.extensions` ನ ಇಂಪೋರ್ಟ್ ಅನ್ನು ಗಮನಿಸಿ. ಈ ಇಂಪೋರ್ಟ್ ಕೇವಲ `User` ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವರ್ಧಿಸುವ ಅದರ ಸೈಡ್ ಎಫೆಕ್ಟ್‌ಗಾಗಿ ಮಾತ್ರ. ಈ ಇಂಪೋರ್ಟ್ ಇಲ್ಲದಿದ್ದರೆ, ವರ್ಧನೆಯು ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನಕ್ಕಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವು ಪ್ರಬಲ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದರೂ, ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಅದನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸುವುದು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವುದು ಅತ್ಯಗತ್ಯ:

• ಅತಿಯಾದ ಬಳಕೆ ತಪ್ಪಿಸಿ: ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಅತಿಯಾಗಿ ಬಳಸಬೇಡಿ. ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ, ES ಮಾಡ್ಯೂಲ್‌ಗಳು ಸ್ವಚ್ಛವಾದ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ.
• ಸ್ಪಷ್ಟವಾಗಿರಿ: ನೀವು ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಯಾವಾಗ ಮತ್ತು ಏಕೆ ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ದಾಖಲಿಸಿ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವರ್ಧಿಸುವಾಗ ಅಥವಾ ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು ವಿಸ್ತರಿಸುವಾಗ.
• ಸ್ಥಿರತೆಯನ್ನು ಕಾಪಾಡಿ: ಒಂದೇ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಘೋಷಣೆಗಳು ಸ್ಥಿರವಾಗಿವೆಯೇ ಮತ್ತು ಸ್ಪಷ್ಟವಾದ ಕೋಡಿಂಗ್ ಶೈಲಿಯನ್ನು ಅನುಸರಿಸುತ್ತವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಪರ್ಯಾಯಗಳನ್ನು ಪರಿಗಣಿಸಿ: ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸುವ ಮೊದಲು, ಇನ್ಹೆರಿಟೆನ್ಸ್, ಕಾಂಪೊಸಿಷನ್, ಅಥವಾ ಮಾಡ್ಯೂಲ್ ವರ್ಧನೆಯಂತಹ ಇತರ ತಂತ್ರಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವೇ ಎಂದು ಪರಿಗಣಿಸಿ.
• ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ: ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸಿದ ನಂತರ, ವಿಶೇಷವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ಗಳು ಅಥವಾ ಲೈಬ್ರರಿಗಳನ್ನು ಮಾರ್ಪಡಿಸುವಾಗ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಯಾವಾಗಲೂ ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
• ಸಾಧ್ಯವಾದಾಗ ಆಧುನಿಕ ಮಾಡ್ಯೂಲ್ ವಿಧಾನವನ್ನು ಬಳಸಿ: ಉತ್ತಮ ಮಾಡ್ಯುಲಾರಿಟಿ ಮತ್ತು ಟೂಲಿಂಗ್ ಬೆಂಬಲಕ್ಕಾಗಿ `/// ` ಡೈರೆಕ್ಟಿವ್‌ಗಳಿಗಿಂತ ES ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಿ.

ಜಾಗತಿಕ ಪರಿಗಣನೆಗಳು

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸುವಾಗ ಈ ಕೆಳಗಿನ ಪರಿಗಣನೆಗಳನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ:

• ಸ್ಥಳೀಕರಣ: ನೀವು ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಥವಾ ಸಂಖ್ಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೆಥಡ್‌ಗಳೊಂದಿಗೆ ಜಾಗತಿಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವರ್ಧಿಸುತ್ತಿದ್ದರೆ, ಸ್ಥಳೀಕರಣವನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ ಮತ್ತು ಲೊಕೇಲ್-ಅವೇರ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಮತ್ತು ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ಗಾಗಿ `Intl` ನಂತಹ ಸೂಕ್ತ API ಗಳನ್ನು ಬಳಸಿ.
• ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್: ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವಿಭಿನ್ನ ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಸಾಂಸ್ಕೃತಿಕ ಸಂಪ್ರದಾಯಗಳು: ದಿನಾಂಕಗಳು, ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಕರೆನ್ಸಿಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವಾಗ ಸಾಂಸ್ಕೃತಿಕ ಸಂಪ್ರದಾಯಗಳ ಬಗ್ಗೆ ಜಾಗೃತರಾಗಿರಿ.
• ಸಮಯ ವಲಯಗಳು: ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಗೊಂದಲ ಮತ್ತು ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಮಯ ವಲಯಗಳನ್ನು ಸರಿಯಾಗಿ ನಿಭಾಯಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ದೃಢವಾದ ಸಮಯ ವಲಯ ಬೆಂಬಲಕ್ಕಾಗಿ Moment.js ಅಥವಾ date-fns ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ.
• ಪ್ರವೇಶಿಸುವಿಕೆ: WCAG ನಂತಹ ಪ್ರವೇಶಿಸುವಿಕೆ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ಅನುಸರಿಸಿ, ವಿಕಲಾಂಗ ಬಳಕೆದಾರರಿಗೆ ನಿಮ್ಮ ಕೋಡ್ ಪ್ರವೇಶಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

`Intl` (ಅಂತಾರಾಷ್ಟ್ರೀಕರಣ API) ನೊಂದಿಗೆ ಸ್ಥಳೀಕರಣದ ಉದಾಹರಣೆ:

// number.extensions.d.ts
declare global {
  interface Number {
    toCurrencyString(locale: string, currency: string): string;
  }
}

Number.prototype.toCurrencyString = function(locale: string, currency: string) {
  return new Intl.NumberFormat(locale, {
    style: 'currency',
    currency: currency,
  }).format(this);
};

const price = 1234.56;

console.log(price.toCurrencyString('en-US', 'USD')); // Output: $1,234.56
console.log(price.toCurrencyString('de-DE', 'EUR')); // Output: 1.234,56 €
console.log(price.toCurrencyString('ja-JP', 'JPY')); // Output: ￥1,235

ಈ ಉದಾಹರಣೆಯು `Intl.NumberFormat` API ಅನ್ನು ಬಳಸಿಕೊಂಡು `Number` ಪ್ರೊಟೊಟೈಪ್‌ಗೆ `toCurrencyString` ಮೆಥಡ್ ಅನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಇದು ವಿಭಿನ್ನ ಲೊಕೇಲ್‌ಗಳು ಮತ್ತು ಕರೆನ್ಸಿಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಸಂಖ್ಯೆಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವು ಲೈಬ್ರರಿಗಳನ್ನು ವಿಸ್ತರಿಸಲು, ಕೋಡ್ ಅನ್ನು ಮಾಡ್ಯುಲೈಸ್ ಮಾಡಲು ಮತ್ತು ಸಂಕೀರ್ಣ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ವಿವರಿಸಲಾದ ಸುಧಾರಿತ ಮಾದರಿಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಸ್ವಚ್ಛವಾದ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಬರೆಯಲು ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಆದಾಗ್ಯೂ, ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ES ಮಾಡ್ಯೂಲ್‌ಗಳು ಹೆಚ್ಚಾಗಿ ಆದ್ಯತೆಯ ವಿಧಾನವೆಂದು ನೆನಪಿಡಿ, ಮತ್ತು ನೇಮ್‌ಸ್ಪೇಸ್ ವಿಲೀನವನ್ನು ವ್ಯೂಹಾತ್ಮಕವಾಗಿ ಮತ್ತು ವಿವೇಚನೆಯಿಂದ ಬಳಸಬೇಕು. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಪ್ರಪಂಚದಾದ್ಯಂತದ ಬಳಕೆದಾರರಿಗೆ ಪ್ರವೇಶಿಸಬಹುದಾದ ಮತ್ತು ಬಳಸಬಹುದಾದಂತೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ನಿಮ್ಮ ಕೋಡ್‌ನ ಜಾಗತಿಕ ಪರಿಣಾಮಗಳನ್ನು ಯಾವಾಗಲೂ ಪರಿಗಣಿಸಿ, ವಿಶೇಷವಾಗಿ ಸ್ಥಳೀಕರಣ, ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್ ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸಂಪ್ರದಾಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ.